// Copyright 2005, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Author: wan@google.com (Zhanyong Wan)
//
// The Google C++ Testing Framework (Google Test)
//
// This header file defines the public API for Google Test.  It should be
// included by any test program that uses Google Test.
//
// IMPORTANT NOTE: Due to limitation of the C++ language, we have to
// leave some internal implementation details in this header file.
// They are clearly marked by comments like this:
//
//   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
//
// Such code is NOT meant to be used by a user directly, and is subject
// to CHANGE WITHOUT NOTICE.  Therefore DO NOT DEPEND ON IT in a user
// program!
//
// Acknowledgment: Google Test borrowed the idea of automatic test
// registration from Barthelemy Dagenais' (barthelemy@prologique.com)
// easyUnit framework.

#ifndef GTEST_INCLUDE_GTEST_GTEST_H_
#define GTEST_INCLUDE_GTEST_GTEST_H_

#include <limits>
#include <vector>

#include "gtest/internal/gtest-internal.h"
#include "gtest/internal/gtest-string.h"
#include "gtest/gtest-death-test.h"
#include "gtest/gtest-message.h"
#include "gtest/gtest-param-test.h"
#include "gtest/gtest-printers.h"
#include "gtest/gtest_prod.h"
#include "gtest/gtest-test-part.h"
#include "gtest/gtest-typed-test.h"

// Depending on the platform, different string classes are available.
// On Linux, in addition to ::std::string, Google also makes use of
// class ::string, which has the same interface as ::std::string, but
// has a different implementation.
//
// The user can define GTEST_HAS_GLOBAL_STRING to 1 to indicate that
// ::string is available AND is a distinct type to ::std::string, or
// define it to 0 to indicate otherwise.
//
// If the user's ::std::string and ::string are the same class due to
// aliasing, he should define GTEST_HAS_GLOBAL_STRING to 0.
//
// If the user doesn't define GTEST_HAS_GLOBAL_STRING, it is defined
// heuristically.

namespace testing
{

    // Declares the flags.

    // This flag temporary enables the disabled tests.
    GTEST_DECLARE_bool_(also_run_disabled_tests);

    // This flag brings the debugger on an assertion failure.
    GTEST_DECLARE_bool_(break_on_failure);

    // This flag controls whether Google Test catches all test-thrown exceptions
    // and logs them as failures.
    GTEST_DECLARE_bool_(catch_exceptions);

    // This flag enables using colors in terminal output. Available values are
    // "yes" to enable colors, "no" (disable colors), or "auto" (the default)
    // to let Google Test decide.
    GTEST_DECLARE_string_(color);

    // This flag sets up the filter to select by name using a glob pattern
    // the tests to run. If the filter is not given all tests are executed.
    GTEST_DECLARE_string_(filter);

    // This flag causes the Google Test to list tests. None of the tests listed
    // are actually run if the flag is provided.
    GTEST_DECLARE_bool_(list_tests);

    // This flag controls whether Google Test emits a detailed XML report to a file
    // in addition to its normal textual output.
    GTEST_DECLARE_string_(output);

    // This flags control whether Google Test prints the elapsed time for each
    // test.
    GTEST_DECLARE_bool_(print_time);

    // This flag specifies the random number seed.
    GTEST_DECLARE_int32_(random_seed);

    // This flag sets how many times the tests are repeated. The default value
    // is 1. If the value is -1 the tests are repeating forever.
    GTEST_DECLARE_int32_(repeat);

    // This flag controls whether Google Test includes Google Test internal
    // stack frames in failure stack traces.
    GTEST_DECLARE_bool_(show_internal_stack_frames);

    // When this flag is specified, tests' order is randomized on every iteration.
    GTEST_DECLARE_bool_(shuffle);

    // This flag specifies the maximum number of stack frames to be
    // printed in a failure message.
    GTEST_DECLARE_int32_(stack_trace_depth);

    // When this flag is specified, a failed assertion will throw an
    // exception if exceptions are enabled, or exit the program with a
    // non-zero code otherwise.
    GTEST_DECLARE_bool_(throw_on_failure);

    // This flag controls whether to attach to gdb when a assertion failure.
    GTEST_DECLARE_string_(db_attach);

    // This flag specifies the path of gdb.
    GTEST_DECLARE_string_(db_command);

    // This flag controls whether to show the result of GetParam().
    GTEST_DECLARE_string_(db_print_param);

    // When this flag is set with a "host:port" string, on supported
    // platforms test results are streamed to the specified port on
    // the specified host machine.
    GTEST_DECLARE_string_(stream_result_to);

    // The upper limit for valid stack trace depths.
    const int kMaxStackTraceDepth = 100;

    namespace internal
    {

        class AssertHelper;
        class DefaultGlobalTestPartResultReporter;
        class ExecDeathTest;
        class NoExecDeathTest;
        class FinalSuccessChecker;
        class GTestFlagSaver;
        class TestResultAccessor;
        class TestEventListenersAccessor;
        class TestEventRepeater;
        class WindowsDeathTest;
        class UnitTestImpl *GetUnitTestImpl();
        void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
                                            const String &message);

        // Converts a streamable value to a String.  A NULL pointer is
        // converted to "(null)".  When the input value is a ::string,
        // ::std::string, ::wstring, or ::std::wstring object, each NUL
        // character in it is replaced with "\\0".
        // Declared in gtest-internal.h but defined here, so that it has access
        // to the definition of the Message class, required by the ARM
        // compiler.
        template <typename T>
        String StreamableToString(const T &streamable)
        {
            return (Message() << streamable).GetString();
        }

    }  // namespace internal

    // The friend relationship of some of these classes is cyclic.
    // If we don't forward declare them the compiler might confuse the classes
    // in friendship clauses with same named classes on the scope.
    class Test;
    class TestCase;
    class TestInfo;
    class UnitTest;

    // A class for indicating whether an assertion was successful.  When
    // the assertion wasn't successful, the AssertionResult object
    // remembers a non-empty message that describes how it failed.
    //
    // To create an instance of this class, use one of the factory functions
    // (AssertionSuccess() and AssertionFailure()).
    //
    // This class is useful for two purposes:
    //   1. Defining predicate functions to be used with Boolean test assertions
    //      EXPECT_TRUE/EXPECT_FALSE and their ASSERT_ counterparts
    //   2. Defining predicate-format functions to be
    //      used with predicate assertions (ASSERT_PRED_FORMAT*, etc).
    //
    // For example, if you define IsEven predicate:
    //
    //   testing::AssertionResult IsEven(int n) {
    //     if ((n % 2) == 0)
    //       return testing::AssertionSuccess();
    //     else
    //       return testing::AssertionFailure() << n << " is odd";
    //   }
    //
    // Then the failed expectation EXPECT_TRUE(IsEven(Fib(5)))
    // will print the message
    //
    //   Value of: IsEven(Fib(5))
    //     Actual: false (5 is odd)
    //   Expected: true
    //
    // instead of a more opaque
    //
    //   Value of: IsEven(Fib(5))
    //     Actual: false
    //   Expected: true
    //
    // in case IsEven is a simple Boolean predicate.
    //
    // If you expect your predicate to be reused and want to support informative
    // messages in EXPECT_FALSE and ASSERT_FALSE (negative assertions show up
    // about half as often as positive ones in our tests), supply messages for
    // both success and failure cases:
    //
    //   testing::AssertionResult IsEven(int n) {
    //     if ((n % 2) == 0)
    //       return testing::AssertionSuccess() << n << " is even";
    //     else
    //       return testing::AssertionFailure() << n << " is odd";
    //   }
    //
    // Then a statement EXPECT_FALSE(IsEven(Fib(6))) will print
    //
    //   Value of: IsEven(Fib(6))
    //     Actual: true (8 is even)
    //   Expected: false
    //
    // NB: Predicates that support negative Boolean assertions have reduced
    // performance in positive ones so be careful not to use them in tests
    // that have lots (tens of thousands) of positive Boolean assertions.
    //
    // To use this class with EXPECT_PRED_FORMAT assertions such as:
    //
    //   // Verifies that Foo() returns an even number.
    //   EXPECT_PRED_FORMAT1(IsEven, Foo());
    //
    // you need to define:
    //
    //   testing::AssertionResult IsEven(const char* expr, int n) {
    //     if ((n % 2) == 0)
    //       return testing::AssertionSuccess();
    //     else
    //       return testing::AssertionFailure()
    //         << "Expected: " << expr << " is even\n  Actual: it's " << n;
    //   }
    //
    // If Foo() returns 5, you will see the following message:
    //
    //   Expected: Foo() is even
    //     Actual: it's 5
    //
    class GTEST_API_ AssertionResult
    {
    public:
        // Copy constructor.
        // Used in EXPECT_TRUE/FALSE(assertion_result).
        AssertionResult(const AssertionResult &other);
        // Used in the EXPECT_TRUE/FALSE(bool_expression).
        explicit AssertionResult(bool success) : success_(success)
        {
            auto_increase_env_var("btest_total_test_assertions_");
            auto_increase_env_var("btest_each_test_assertions_");
        }

        // Returns true iff the assertion succeeded.
        operator bool() const
        {
            return success_;    // NOLINT
        }

        // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
        AssertionResult operator!() const;

        // Returns the text streamed into this AssertionResult. Test assertions
        // use it when they fail (i.e., the predicate's outcome doesn't match the
        // assertion's expectation). When nothing has been streamed into the
        // object, returns an empty string.
        const char *message() const
        {
            return message_.get() != NULL ?  message_->c_str() : "";
        }
        // TODO(vladl@google.com): Remove this after making sure no clients use it.
        // Deprecated; please use message() instead.
        const char *failure_message() const
        {
            return message();
        }

        const char *success_message() const
        {
            return message();
        }

        // Streams a custom failure message into this object.
        template <typename T> AssertionResult &operator<<(const T &value)
        {
            AppendMessage(Message() << value);
            return *this;
        }

        // Allows streaming basic output manipulators such as endl or flush into
        // this object.
        AssertionResult &operator<<(
            ::std::ostream & (*basic_manipulator)(::std::ostream &stream))
        {
            AppendMessage(Message() << basic_manipulator);
            return *this;
        }

    private:
        // Appends the contents of message to message_.
        void AppendMessage(const Message &a_message)
        {
            if (message_.get() == NULL)
            {
                message_.reset(new ::std::string);
            }

            message_->append(a_message.GetString().c_str());
        }

        // Stores result of the assertion predicate.
        bool success_;
        // Stores the message describing the condition in case the expectation
        // construct is not satisfied with the predicate's outcome.
        // Referenced via a pointer to avoid taking too much stack frame space
        // with test assertions.
        internal::scoped_ptr< ::std::string> message_;

        // btest#auto add 1 to env var
        void auto_increase_env_var(const char *varname)
        {
            char *var_value_str_ = getenv(varname);
            long varvalue_ = var_value_str_ == NULL ? 0 : atol(var_value_str_);
            stringstream ss;
            ss << ++varvalue_;
            setenv(varname, ss.str().c_str(), 1);
        }

        GTEST_DISALLOW_ASSIGN_(AssertionResult);
    };

    // Makes a successful assertion result.
    GTEST_API_ AssertionResult AssertionSuccess();

    GTEST_API_ AssertionResult AssertionSuccess(const Message &msg);

    // Makes a failed assertion result.
    GTEST_API_ AssertionResult AssertionFailure();

    // Makes a failed assertion result with the given failure message.
    // Deprecated; use AssertionFailure() << msg.
    GTEST_API_ AssertionResult AssertionFailure(const Message &msg);

    // The abstract class that all tests inherit from.
    //
    // In Google Test, a unit test program contains one or many TestCases, and
    // each TestCase contains one or many Tests.
    //
    // When you define a test using the TEST macro, you don't need to
    // explicitly derive from Test - the TEST macro automatically does
    // this for you.
    //
    // The only time you derive from Test is when defining a test fixture
    // to be used a TEST_F.  For example:
    //
    //   class FooTest : public testing::Test {
    //    protected:
    //     virtual void SetUp() { ... }
    //     virtual void TearDown() { ... }
    //     ...
    //   };
    //
    //   TEST_F(FooTest, Bar) { ... }
    //   TEST_F(FooTest, Baz) { ... }
    //
    // Test is not copyable.
    class GTEST_API_ Test
    {
    public:
        friend class TestInfo;

        // Defines types for pointers to functions that set up and tear down
        // a test case.
        typedef internal::SetUpTestCaseFunc SetUpTestCaseFunc;
        typedef internal::TearDownTestCaseFunc TearDownTestCaseFunc;

        // The d'tor is virtual as we intend to inherit from Test.
        virtual ~Test();

        // Sets up the stuff shared by all tests in this test case.
        //
        // Google Test will call Foo::SetUpTestCase() before running the first
        // test in test case Foo.  Hence a sub-class can define its own
        // SetUpTestCase() method to shadow the one defined in the super
        // class.
        static void SetUpTestCase() {}

        // Tears down the stuff shared by all tests in this test case.
        //
        // Google Test will call Foo::TearDownTestCase() after running the last
        // test in test case Foo.  Hence a sub-class can define its own
        // TearDownTestCase() method to shadow the one defined in the super
        // class.
        static void TearDownTestCase() {}

        // Returns true iff the current test has a fatal failure.
        static bool HasFatalFailure();

        // Returns true iff the current test has a non-fatal failure.
        static bool HasNonfatalFailure();

        // Returns true iff the current test has a (either fatal or
        // non-fatal) failure.
        static bool HasFailure()
        {
            return HasFatalFailure() || HasNonfatalFailure();
        }

        // Logs a property for the current test.  Only the last value for a given
        // key is remembered.
        // These are public static so they can be called from utility functions
        // that are not members of the test fixture.
        // The arguments are const char* instead strings, as Google Test is used
        // on platforms where string doesn't compile.
        //
        // Note that a driving consideration for these RecordProperty methods
        // was to produce xml output suited to the Greenspan charting utility,
        // which at present will only chart values that fit in a 32-bit int. It
        // is the user's responsibility to restrict their values to 32-bit ints
        // if they intend them to be used with Greenspan.
        static void RecordProperty(const char *key, const char *value);
        static void RecordProperty(const char *key, int value);

    protected:
        // Creates a Test object.
        Test();

        // Sets up the test fixture.
        virtual void SetUp();

        // Tears down the test fixture.
        virtual void TearDown();

    private:
        // Returns true iff the current test has the same fixture class as
        // the first test in the current test case.
        static bool HasSameFixtureClass();

        // Runs the test after the test fixture has been set up.
        //
        // A sub-class must implement this to define the test logic.
        //
        // DO NOT OVERRIDE THIS FUNCTION DIRECTLY IN A USER PROGRAM.
        // Instead, use the TEST or TEST_F macro.
        virtual void TestBody() = 0;

        // Sets up, executes, and tears down the test.
        void Run();

        // Deletes self.  We deliberately pick an unusual name for this
        // internal method to avoid clashing with names used in user TESTs.
        void DeleteSelf_()
        {
            delete this;
        }

        // Uses a GTestFlagSaver to save and restore all Google Test flags.
        const internal::GTestFlagSaver *const gtest_flag_saver_;

        // Often a user mis-spells SetUp() as Setup() and spends a long time
        // wondering why it is never called by Google Test.  The declaration of
        // the following method is solely for catching such an error at
        // compile time:
        //
        //   - The return type is deliberately chosen to be not void, so it
        //   will be a conflict if a user declares void Setup() in his test
        //   fixture.
        //
        //   - This method is private, so it will be another compiler error
        //   if a user calls it from his test fixture.
        //
        // DO NOT OVERRIDE THIS FUNCTION.
        //
        // If you see an error about overriding the following function or
        // about it being private, you have mis-spelled SetUp() as Setup().
        struct Setup_should_be_spelled_SetUp {};
        virtual Setup_should_be_spelled_SetUp *Setup()
        {
            return NULL;
        }

        // We disallow copying Tests.
        GTEST_DISALLOW_COPY_AND_ASSIGN_(Test);
    };

    typedef internal::TimeInMillis TimeInMillis;

    // A copyable object representing a user specified test property which can be
    // output as a key/value string pair.
    //
    // Don't inherit from TestProperty as its destructor is not virtual.
    class TestProperty
    {
    public:
        // C'tor.  TestProperty does NOT have a default constructor.
        // Always use this constructor (with parameters) to create a
        // TestProperty object.
        TestProperty(const char *a_key, const char *a_value) :
            key_(a_key), value_(a_value)
        {
        }

        // Gets the user supplied key.
        const char *key() const
        {
            return key_.c_str();
        }

        // Gets the user supplied value.
        const char *value() const
        {
            return value_.c_str();
        }

        // Sets a new value, overriding the one supplied in the constructor.
        void SetValue(const char *new_value)
        {
            value_ = new_value;
        }

    private:
        // The key supplied by the user.
        internal::String key_;
        // The value supplied by the user.
        internal::String value_;
    };

    // The result of a single Test.  This includes a list of
    // TestPartResults, a list of TestProperties, a count of how many
    // death tests there are in the Test, and how much time it took to run
    // the Test.
    //
    // TestResult is not copyable.
    class GTEST_API_ TestResult
    {
    public:
        // Creates an empty TestResult.
        TestResult();

        // D'tor.  Do not inherit from TestResult.
        ~TestResult();

        // Gets the number of all test parts.  This is the sum of the number
        // of successful test parts and the number of failed test parts.
        int total_part_count() const;

        // Returns the number of the test properties.
        int test_property_count() const;

        // Returns true iff the test passed (i.e. no test part failed).
        bool Passed() const
        {
            return !Failed();
        }

        // Returns true iff the test failed.
        bool Failed() const;

        // Returns true iff the test fatally failed.
        bool HasFatalFailure() const;

        // Returns true iff the test has a non-fatal failure.
        bool HasNonfatalFailure() const;

        // Returns the elapsed time, in milliseconds.
        TimeInMillis elapsed_time() const
        {
            return elapsed_time_;
        }

        // Returns the i-th test part result among all the results. i can range
        // from 0 to test_property_count() - 1. If i is not in that range, aborts
        // the program.
        const TestPartResult &GetTestPartResult(int i) const;

        // Returns the i-th test property. i can range from 0 to
        // test_property_count() - 1. If i is not in that range, aborts the
        // program.
        const TestProperty &GetTestProperty(int i) const;

    private:
        friend class TestInfo;
        friend class UnitTest;
        friend class internal::DefaultGlobalTestPartResultReporter;
        friend class internal::ExecDeathTest;
        friend class internal::TestResultAccessor;
        friend class internal::UnitTestImpl;
        friend class internal::WindowsDeathTest;

        // Gets the vector of TestPartResults.
        const std::vector<TestPartResult>& test_part_results() const
        {
            return test_part_results_;
        }

        // Gets the vector of TestProperties.
        const std::vector<TestProperty>& test_properties() const
        {
            return test_properties_;
        }

        // Sets the elapsed time.
        void set_elapsed_time(TimeInMillis elapsed)
        {
            elapsed_time_ = elapsed;
        }

        // Adds a test property to the list. The property is validated and may add
        // a non-fatal failure if invalid (e.g., if it conflicts with reserved
        // key names). If a property is already recorded for the same key, the
        // value will be updated, rather than storing multiple values for the same
        // key.
        void RecordProperty(const TestProperty &test_property);

        // Adds a failure if the key is a reserved attribute of Google Test
        // testcase tags.  Returns true if the property is valid.
        // TODO(russr): Validate attribute names are legal and human readable.
        static bool ValidateTestProperty(const TestProperty &test_property);

        // Adds a test part result to the list.
        void AddTestPartResult(const TestPartResult &test_part_result);

        // Returns the death test count.
        int death_test_count() const
        {
            return death_test_count_;
        }

        // Increments the death test count, returning the new count.
        int increment_death_test_count()
        {
            return ++death_test_count_;
        }

        // Clears the test part results.
        void ClearTestPartResults();

        // Clears the object.
        void Clear();

        // Protects mutable state of the property vector and of owned
        // properties, whose values may be updated.
        internal::Mutex test_properites_mutex_;

        // The vector of TestPartResults
        std::vector<TestPartResult> test_part_results_;
        // The vector of TestProperties
        std::vector<TestProperty> test_properties_;
        // Running count of death tests.
        int death_test_count_;
        // The elapsed time, in milliseconds.
        TimeInMillis elapsed_time_;

        // We disallow copying TestResult.
        GTEST_DISALLOW_COPY_AND_ASSIGN_(TestResult);
    };  // class TestResult

    // A TestInfo object stores the following information about a test:
    //
    //   Test case name
    //   Test name
    //   Whether the test should be run
    //   A function pointer that creates the test object when invoked
    //   Test result
    //
    // The constructor of TestInfo registers itself with the UnitTest
    // singleton such that the RUN_ALL_TESTS() macro knows which tests to
    // run.
    class GTEST_API_ TestInfo
    {
    public:
        // Destructs a TestInfo object.  This function is not virtual, so
        // don't inherit from TestInfo.
        ~TestInfo();

        // Returns the test case name.
        const char *test_case_name() const
        {
            return test_case_name_.c_str();
        }

        // Returns the test name.
        const char *name() const
        {
            return name_.c_str();
        }

        // Returns the name of the parameter type, or NULL if this is not a typed
        // or a type-parameterized test.
        const char *type_param() const
        {
            if (type_param_.get() != NULL)
            {
                return type_param_->c_str();
            }

            return NULL;
        }

        // Returns the text representation of the value parameter, or NULL if this
        // is not a value-parameterized test.
        const char *value_param() const
        {
            if (value_param_.get() != NULL)
            {
                return value_param_->c_str();
            }

            return NULL;
        }

        // Returns true if this test should run, that is if the test is not disabled
        // (or it is disabled but the also_run_disabled_tests flag has been specified)
        // and its full name matches the user-specified filter.
        //
        // Google Test allows the user to filter the tests by their full names.
        // The full name of a test Bar in test case Foo is defined as
        // "Foo.Bar".  Only the tests that match the filter will run.
        //
        // A filter is a colon-separated list of glob (not regex) patterns,
        // optionally followed by a '-' and a colon-separated list of
        // negative patterns (tests to exclude).  A test is run if it
        // matches one of the positive patterns and does not match any of
        // the negative patterns.
        //
        // For example, *A*:Foo.* is a filter that matches any string that
        // contains the character 'A' or starts with "Foo.".
        bool should_run() const
        {
            return should_run_;
        }

        // Returns the result of the test.
        const TestResult *result() const
        {
            return &result_;
        }

    private:

#if GTEST_HAS_DEATH_TEST
        friend class internal::DefaultDeathTestFactory;
#endif  // GTEST_HAS_DEATH_TEST
        friend class Test;
        friend class TestCase;
        friend class internal::UnitTestImpl;
        friend TestInfo *internal::MakeAndRegisterTestInfo(
            const char *test_case_name, const char *name,
            const char *type_param,
            const char *value_param,
            internal::TypeId fixture_class_id,
            Test::SetUpTestCaseFunc set_up_tc,
            Test::TearDownTestCaseFunc tear_down_tc,
            internal::TestFactoryBase *factory);

        // Constructs a TestInfo object. The newly constructed instance assumes
        // ownership of the factory object.
        TestInfo(const char *test_case_name, const char *name,
                 const char *a_type_param,
                 const char *a_value_param,
                 internal::TypeId fixture_class_id,
                 internal::TestFactoryBase *factory);

        // Increments the number of death tests encountered in this test so
        // far.
        int increment_death_test_count()
        {
            return result_.increment_death_test_count();
        }

        // Creates the test object, runs it, records its result, and then
        // deletes it.
        void Run(void *, void *);

        // Creates the test object, runs it, records its result, and then
        // deletes it.
        void Run();

        static void ClearTestResult(TestInfo *test_info)
        {
            test_info->result_.Clear();
        }

        // These fields are immutable properties of the test.
        const std::string test_case_name_;     // Test case name
        const std::string name_;               // Test name
        // Name of the parameter type, or NULL if this is not a typed or a
        // type-parameterized test.
        const internal::scoped_ptr<const ::std::string> type_param_;
        // Text representation of the value parameter, or NULL if this is not a
        // value-parameterized test.
        const internal::scoped_ptr<const ::std::string> value_param_;
        const internal::TypeId fixture_class_id_;   // ID of the test fixture class
        bool should_run_;                 // True iff this test should run
        bool is_disabled_;                // True iff this test is disabled
        bool matches_filter_;             // True if this test matches the
        // user-specified filter.
        internal::TestFactoryBase *const factory_;  // The factory that creates
        // the test object

        // This field is mutable and needs to be reset before running the
        // test for the second time.
        TestResult result_;

        GTEST_DISALLOW_COPY_AND_ASSIGN_(TestInfo);
    };

    // A test case, which consists of a vector of TestInfos.
    //
    // TestCase is not copyable.
    class GTEST_API_ TestCase
    {
    public:
        // Creates a TestCase with the given name.
        //
        // TestCase does NOT have a default constructor.  Always use this
        // constructor to create a TestCase object.
        //
        // Arguments:
        //
        //   name:         name of the test case
        //   a_type_param: the name of the test's type parameter, or NULL if
        //                 this is not a type-parameterized test.
        //   set_up_tc:    pointer to the function that sets up the test case
        //   tear_down_tc: pointer to the function that tears down the test case
        TestCase(const char *name, const char *a_type_param,
                 Test::SetUpTestCaseFunc set_up_tc,
                 Test::TearDownTestCaseFunc tear_down_tc);

        // Destructor of TestCase.
        virtual ~TestCase();

        // Gets the name of the TestCase.
        const char *name() const
        {
            return name_.c_str();
        }

        // Returns the name of the parameter type, or NULL if this is not a
        // type-parameterized test case.
        const char *type_param() const
        {
            if (type_param_.get() != NULL)
            {
                return type_param_->c_str();
            }

            return NULL;
        }

        // Returns true if any test in this test case should run.
        bool should_run() const
        {
            return should_run_;
        }

        // Gets the number of successful tests in this test case.
        int successful_test_count() const;

        // Gets the number of failed tests in this test case.
        int failed_test_count() const;

        // Gets the number of disabled tests in this test case.
        int disabled_test_count() const;

        // Get the number of tests in this test case that should run.
        int test_to_run_count() const;

        // Gets the number of all tests in this test case.
        int total_test_count() const;

        // Returns true iff the test case passed.
        bool Passed() const
        {
            return !Failed();
        }

        // Returns true iff the test case failed.
        bool Failed() const
        {
            return failed_test_count() > 0;
        }

        // Returns the elapsed time, in milliseconds.
        TimeInMillis elapsed_time() const
        {
            return elapsed_time_;
        }

        // Returns the i-th test among all the tests. i can range from 0 to
        // total_test_count() - 1. If i is not in that range, returns NULL.
        const TestInfo *GetTestInfo(int i) const;

    private:
        friend class Test;
        friend class internal::UnitTestImpl;

        // Gets the (mutable) vector of TestInfos in this TestCase.
        std::vector<TestInfo *>& test_info_list()
        {
            return test_info_list_;
        }

        // Gets the (immutable) vector of TestInfos in this TestCase.
        const std::vector<TestInfo *>& test_info_list() const
        {
            return test_info_list_;
        }

        // Returns the i-th test among all the tests. i can range from 0 to
        // total_test_count() - 1. If i is not in that range, returns NULL.
        TestInfo *GetMutableTestInfo(int i);

        // Sets the should_run member.
        void set_should_run(bool should)
        {
            should_run_ = should;
        }

        // Adds a TestInfo to this test case.  Will delete the TestInfo upon
        // destruction of the TestCase object.
        void AddTestInfo(TestInfo *test_info);

        // Clears the results of all tests in this test case.
        void ClearResult();

        // Clears the results of all tests in the given test case.
        static void ClearTestCaseResult(TestCase *test_case)
        {
            test_case->ClearResult();
        }

        // Runs every test in this TestCase.
        void Run(void *, void *);

        // Runs every test in this TestCase.
        void Run();

        // Runs every test in certain proc
        void Run(int runtype);

        // Runs SetUpTestCase() for this TestCase.  This wrapper is needed
        // for catching exceptions thrown from SetUpTestCase().
        void RunSetUpTestCase()
        {
            (*set_up_tc_)();
        }

        // Runs TearDownTestCase() for this TestCase.  This wrapper is
        // needed for catching exceptions thrown from TearDownTestCase().
        void RunTearDownTestCase()
        {
            (*tear_down_tc_)();
        }

        // Returns true iff test passed.
        static bool TestPassed(const TestInfo *test_info)
        {
            return test_info->should_run() && test_info->result()->Passed();
        }

        // Returns true iff test failed.
        static bool TestFailed(const TestInfo *test_info)
        {
            return test_info->should_run() && test_info->result()->Failed();
        }

        // Returns true iff test is disabled.
        static bool TestDisabled(const TestInfo *test_info)
        {
            return test_info->is_disabled_;
        }

        // Returns true if the given test should run.
        static bool ShouldRunTest(const TestInfo *test_info)
        {
            return test_info->should_run();
        }

        // Shuffles the tests in this test case.
        void ShuffleTests(internal::Random *random);

        // Restores the test order to before the first shuffle.
        void UnshuffleTests();

        // Name of the test case.
        internal::String name_;
        // Name of the parameter type, or NULL if this is not a typed or a
        // type-parameterized test.
        const internal::scoped_ptr<const ::std::string> type_param_;
        // The vector of TestInfos in their original order.  It owns the
        // elements in the vector.
        std::vector<TestInfo *> test_info_list_;
        // Provides a level of indirection for the test list to allow easy
        // shuffling and restoring the test order.  The i-th element in this
        // vector is the index of the i-th test in the shuffled test list.
        std::vector<int> test_indices_;
        // Pointer to the function that sets up the test case.
        Test::SetUpTestCaseFunc set_up_tc_;
        // Pointer to the function that tears down the test case.
        Test::TearDownTestCaseFunc tear_down_tc_;
        // True iff any test in this test case should run.
        bool should_run_;
        // Elapsed time, in milliseconds.
        TimeInMillis elapsed_time_;

        // We disallow copying TestCases.
        GTEST_DISALLOW_COPY_AND_ASSIGN_(TestCase);
    };

    // An Environment object is capable of setting up and tearing down an
    // environment.  The user should subclass this to define his own
    // environment(s).
    //
    // An Environment object does the set-up and tear-down in virtual
    // methods SetUp() and TearDown() instead of the constructor and the
    // destructor, as:
    //
    //   1. You cannot safely throw from a destructor.  This is a problem
    //      as in some cases Google Test is used where exceptions are enabled, and
    //      we may want to implement ASSERT_* using exceptions where they are
    //      available.
    //   2. You cannot use ASSERT_* directly in a constructor or
    //      destructor.
    class Environment
    {
    public:
        // The d'tor is virtual as we need to subclass Environment.
        virtual ~Environment() {}

        // Override this to define how to set up the environment.
        virtual void SetUp() {}

        // Override this to define how to tear down the environment.
        virtual void TearDown() {}
    private:
        // If you see an error about overriding the following function or
        // about it being private, you have mis-spelled SetUp() as Setup().
        struct Setup_should_be_spelled_SetUp {};
        virtual Setup_should_be_spelled_SetUp *Setup()
        {
            return NULL;
        }
    };

    // The interface for tracing execution of tests. The methods are organized in
    // the order the corresponding events are fired.
    class TestEventListener
    {
    public:
        virtual ~TestEventListener() {}

        // Fired before any test activity starts.
        virtual void OnTestProgramStart(const UnitTest &unit_test) = 0;

        // Fired before each iteration of tests starts.  There may be more than
        // one iteration if GTEST_FLAG(repeat) is set. iteration is the iteration
        // index, starting from 0.
        virtual void OnTestIterationStart(const UnitTest &unit_test,
                                          int iteration) = 0;

        // Fired before environment set-up for each iteration of tests starts.
        virtual void OnEnvironmentsSetUpStart(const UnitTest &unit_test) = 0;

        // Fired after environment set-up for each iteration of tests ends.
        virtual void OnEnvironmentsSetUpEnd(const UnitTest &unit_test) = 0;

        // Fired before the test case starts.
        virtual void OnTestCaseStart(const TestCase &test_case) = 0;

        // Fired before the test starts.
        virtual void OnTestStart(const TestInfo &test_info) = 0;

        // Fired after a failed assertion or a SUCCEED() invocation.
        virtual void OnTestPartResult(const TestPartResult &test_part_result) = 0;

        // Fired after the test ends.
        virtual void OnTestEnd(const TestInfo &test_info) = 0;

        // Fired after the test case ends.
        virtual void OnTestCaseEnd(const TestCase &test_case) = 0;

        // Fired before environment tear-down for each iteration of tests starts.
        virtual void OnEnvironmentsTearDownStart(const UnitTest &unit_test) = 0;

        // Fired after environment tear-down for each iteration of tests ends.
        virtual void OnEnvironmentsTearDownEnd(const UnitTest &unit_test) = 0;

        // Fired after each iteration of tests finishes.
        virtual void OnTestIterationEnd(const UnitTest &unit_test,
                                        int iteration) = 0;

        // Fired after all test activities have ended.
        virtual void OnTestProgramEnd(const UnitTest &unit_test) = 0;
    };

    // The convenience class for users who need to override just one or two
    // methods and are not concerned that a possible change to a signature of
    // the methods they override will not be caught during the build.  For
    // comments about each method please see the definition of TestEventListener
    // above.
    class EmptyTestEventListener : public TestEventListener
    {
    public:
        virtual void OnTestProgramStart(const UnitTest & /*unit_test*/) {}
        virtual void OnTestIterationStart(const UnitTest & /*unit_test*/,
                                          int /*iteration*/) {}
        virtual void OnEnvironmentsSetUpStart(const UnitTest & /*unit_test*/) {}
        virtual void OnEnvironmentsSetUpEnd(const UnitTest & /*unit_test*/) {}
        virtual void OnTestCaseStart(const TestCase & /*test_case*/) {}
        virtual void OnTestStart(const TestInfo & /*test_info*/) {}
        virtual void OnTestPartResult(const TestPartResult & /*test_part_result*/) {}
        virtual void OnTestEnd(const TestInfo & /*test_info*/) {}
        virtual void OnTestCaseEnd(const TestCase & /*test_case*/) {}
        virtual void OnEnvironmentsTearDownStart(const UnitTest & /*unit_test*/) {}
        virtual void OnEnvironmentsTearDownEnd(const UnitTest & /*unit_test*/) {}
        virtual void OnTestIterationEnd(const UnitTest & /*unit_test*/,
                                        int /*iteration*/) {}
        virtual void OnTestProgramEnd(const UnitTest & /*unit_test*/) {}
    };

    // TestEventListeners lets users add listeners to track events in Google Test.
    class GTEST_API_ TestEventListeners
    {
    public:
        TestEventListeners();
        ~TestEventListeners();

        // Appends an event listener to the end of the list. Google Test assumes
        // the ownership of the listener (i.e. it will delete the listener when
        // the test program finishes).
        void Append(TestEventListener *listener);

        // Removes the given event listener from the list and returns it.  It then
        // becomes the caller's responsibility to delete the listener. Returns
        // NULL if the listener is not found in the list.
        TestEventListener *Release(TestEventListener *listener);

        // Returns the standard listener responsible for the default console
        // output.  Can be removed from the listeners list to shut down default
        // console output.  Note that removing this object from the listener list
        // with Release transfers its ownership to the caller and makes this
        // function return NULL the next time.
        TestEventListener *default_result_printer() const
        {
            return default_result_printer_;
        }

        // Returns the standard listener responsible for the default XML output
        // controlled by the --gtest_output=xml flag.  Can be removed from the
        // listeners list by users who want to shut down the default XML output
        // controlled by this flag and substitute it with custom one.  Note that
        // removing this object from the listener list with Release transfers its
        // ownership to the caller and makes this function return NULL the next
        // time.
        TestEventListener *default_xml_generator() const
        {
            return default_xml_generator_;
        }

    private:
        friend class TestCase;
        friend class TestInfo;
        friend class internal::DefaultGlobalTestPartResultReporter;
        friend class internal::NoExecDeathTest;
        friend class internal::TestEventListenersAccessor;
        friend class internal::UnitTestImpl;

        // Returns repeater that broadcasts the TestEventListener events to all
        // subscribers.
        TestEventListener *repeater();

        // Sets the default_result_printer attribute to the provided listener.
        // The listener is also added to the listener list and previous
        // default_result_printer is removed from it and deleted. The listener can
        // also be NULL in which case it will not be added to the list. Does
        // nothing if the previous and the current listener objects are the same.
        void SetDefaultResultPrinter(TestEventListener *listener);

        // Sets the default_xml_generator attribute to the provided listener.  The
        // listener is also added to the listener list and previous
        // default_xml_generator is removed from it and deleted. The listener can
        // also be NULL in which case it will not be added to the list. Does
        // nothing if the previous and the current listener objects are the same.
        void SetDefaultXmlGenerator(TestEventListener *listener);

        // Controls whether events will be forwarded by the repeater to the
        // listeners in the list.
        bool EventForwardingEnabled() const;
        void SuppressEventForwarding();

        // The actual list of listeners.
        internal::TestEventRepeater *repeater_;
        // Listener responsible for the standard result output.
        TestEventListener *default_result_printer_;
        // Listener responsible for the creation of the XML output file.
        TestEventListener *default_xml_generator_;

        // We disallow copying TestEventListeners.
        GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventListeners);
    };

    // A UnitTest consists of a vector of TestCases.
    //
    // This is a singleton class.  The only instance of UnitTest is
    // created when UnitTest::GetInstance() is first called.  This
    // instance is never deleted.
    //
    // UnitTest is not copyable.
    //
    // This class is thread-safe as long as the methods are called
    // according to their specification.
    class GTEST_API_ UnitTest
    {
    public:
        // Gets the singleton UnitTest object.  The first time this method
        // is called, a UnitTest object is constructed and returned.
        // Consecutive calls will return the same object.
        static UnitTest *GetInstance();

        void set_proctype(int proc_type)
        {
            proc_type_ = proc_type;
        }

        int get_proctype()
        {
            return proc_type_;
        }

        // Runs all tests in this UnitTest object and prints the result.
        // Returns 0 if successful, or 1 otherwise.
        //
        // This method can only be called from the main thread.
        //
        // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
        int Run(void * , void *) GTEST_MUST_USE_RESULT_;

        int Run() GTEST_MUST_USE_RESULT_;

        int Run(int run_type) GTEST_MUST_USE_RESULT_;

        // Returns the working directory when the first TEST() or TEST_F()
        // was executed.  The UnitTest object owns the string.
        const char *original_working_dir() const;

        // Returns the TestCase object for the test that's currently running,
        // or NULL if no test is running.
        const TestCase *current_test_case() const;

        // Returns the TestInfo object for the test that's currently running,
        // or NULL if no test is running.
        const TestInfo *current_test_info() const;

        // Returns the random seed used at the start of the current test run.
        int random_seed() const;

#if GTEST_HAS_PARAM_TEST
        // Returns the ParameterizedTestCaseRegistry object used to keep track of
        // value-parameterized tests and instantiate and register them.
        //
        // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
        internal::ParameterizedTestCaseRegistry &parameterized_test_registry();
#endif  // GTEST_HAS_PARAM_TEST

        // Gets the number of successful test cases.
        int successful_test_case_count() const;

        // Gets the number of failed test cases.
        int failed_test_case_count() const;

        // Gets the number of all test cases.
        int total_test_case_count() const;

        // Gets the number of all test cases that contain at least one test
        // that should run.
        int test_case_to_run_count() const;

        // Gets the number of successful tests.
        int successful_test_count() const;

        // Gets the number of failed tests.
        int failed_test_count() const;

        // Gets the number of disabled tests.
        int disabled_test_count() const;

        // Gets the number of all tests.
        int total_test_count() const;

        // Gets the number of tests that should run.
        int test_to_run_count() const;

        // Gets the elapsed time, in milliseconds.
        TimeInMillis elapsed_time() const;

        // Returns true iff the unit test passed (i.e. all test cases passed).
        bool Passed() const;

        // Returns true iff the unit test failed (i.e. some test case failed
        // or something outside of all tests failed).
        bool Failed() const;

        // Gets the i-th test case among all the test cases. i can range from 0 to
        // total_test_case_count() - 1. If i is not in that range, returns NULL.
        const TestCase *GetTestCase(int i) const;

        // Returns the list of event listeners that can be used to track events
        // inside Google Test.
        TestEventListeners &listeners();

    private:
        // Registers and returns a global test environment.  When a test
        // program is run, all global test environments will be set-up in
        // the order they were registered.  After all tests in the program
        // have finished, all global test environments will be torn-down in
        // the *reverse* order they were registered.
        //
        // The UnitTest object takes ownership of the given environment.
        //
        // This method can only be called from the main thread.
        Environment *AddEnvironment(Environment *env);

        // Adds a TestPartResult to the current TestResult object.  All
        // Google Test assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc)
        // eventually call this to report their results.  The user code
        // should use the assertion macros instead of calling this directly.
        void AddTestPartResult(TestPartResult::Type result_type,
                               const char *file_name,
                               int line_number,
                               const internal::String &message,
                               const internal::String &os_stack_trace);

        // Adds a TestProperty to the current TestResult object. If the result already
        // contains a property with the same key, the value will be updated.
        void RecordPropertyForCurrentTest(const char *key, const char *value);

        // Gets the i-th test case among all the test cases. i can range from 0 to
        // total_test_case_count() - 1. If i is not in that range, returns NULL.
        TestCase *GetMutableTestCase(int i);

        // Accessors for the implementation object.
        internal::UnitTestImpl *impl()
        {
            return impl_;
        }
        const internal::UnitTestImpl *impl() const
        {
            return impl_;
        }

        // These classes and funcions are friends as they need to access private
        // members of UnitTest.
        friend class Test;
        friend class internal::AssertHelper;
        friend class internal::ScopedTrace;
        friend Environment *AddGlobalTestEnvironment(Environment *env);
        friend internal::UnitTestImpl *internal::GetUnitTestImpl();
        friend void internal::ReportFailureInUnknownLocation(
            TestPartResult::Type result_type,
            const internal::String &message);

        // Creates an empty UnitTest.
        UnitTest();

        // D'tor
        virtual ~UnitTest();

        // Pushes a trace defined by SCOPED_TRACE() on to the per-thread
        // Google Test trace stack.
        void PushGTestTrace(const internal::TraceInfo &trace);

        // Pops a trace from the per-thread Google Test trace stack.
        void PopGTestTrace();

        // Protects mutable state in *impl_.  This is mutable as some const
        // methods need to lock it too.
        mutable internal::Mutex mutex_;

        // Opaque implementation object.  This field is never changed once
        // the object is constructed.  We don't mark it as const here, as
        // doing so will cause a warning in the constructor of UnitTest.
        // Mutable state in *impl_ is protected by mutex_.
        internal::UnitTestImpl *impl_;

        int proc_type_;

        // We disallow copying UnitTest.
        GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTest);
    };

    // A convenient wrapper for adding an environment for the test
    // program.
    //
    // You should call this before RUN_ALL_TESTS() is called, probably in
    // main().  If you use gtest_main, you need to call this before main()
    // starts for it to take effect.  For example, you can define a global
    // variable like this:
    //
    //   testing::Environment* const foo_env =
    //       testing::AddGlobalTestEnvironment(new FooEnvironment);
    //
    // However, we strongly recommend you to write your own main() and
    // call AddGlobalTestEnvironment() there, as relying on initialization
    // of global variables makes the code harder to read and may cause
    // problems when you register multiple environments from different
    // translation units and the environments have dependencies among them
    // (remember that the compiler doesn't guarantee the order in which
    // global variables from different translation units are initialized).
    inline Environment *AddGlobalTestEnvironment(Environment *env)
    {
        return UnitTest::GetInstance()->AddEnvironment(env);
    }

    // Initializes Google Test.  This must be called before calling
    // RUN_ALL_TESTS().  In particular, it parses a command line for the
    // flags that Google Test recognizes.  Whenever a Google Test flag is
    // seen, it is removed from argv, and *argc is decremented.
    //
    // No value is returned.  Instead, the Google Test flag variables are
    // updated.
    //
    // Calling the function for the second time has no user-visible effect.
    GTEST_API_ void InitGoogleTest(int *argc, char **argv);

    // This overloaded version can be used in Windows programs compiled in
    // UNICODE mode.
    GTEST_API_ void InitGoogleTest(int *argc, wchar_t **argv);

    // reset gtest variables so that it can initialize more than once
    GTEST_API_ void ResetGoogleTest();

    namespace internal
    {

        // Formats a comparison assertion (e.g. ASSERT_EQ, EXPECT_LT, and etc)
        // operand to be used in a failure message.  The type (but not value)
        // of the other operand may affect the format.  This allows us to
        // print a char* as a raw pointer when it is compared against another
        // char*, and print it as a C string when it is compared against an
        // std::string object, for example.
        //
        // The default implementation ignores the type of the other operand.
        // Some specialized versions are used to handle formatting wide or
        // narrow C strings.
        //
        // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
        template <typename T1, typename T2>
        String FormatForComparisonFailureMessage(const T1 &value,
                const T2 & /* other_operand */)
        {
            // C++Builder compiles this incorrectly if the namespace isn't explicitly
            // given.
            return ::testing::PrintToString(value);
        }

        // The helper function for {ASSERT|EXPECT}_EQ.
        template <typename T1, typename T2>
        AssertionResult CmpHelperEQ(const char *expected_expression,
                                    const char *actual_expression,
                                    const T1 &expected,
                                    const T2 &actual)
        {
#ifdef _MSC_VER
# pragma warning(push)          // Saves the current warning state.
# pragma warning(disable:4389)  // Temporarily disables warning on
            // signed/unsigned mismatch.
#endif

            if (expected == actual)
            {
                return EqSuccess(expected_expression,
                                 actual_expression,
                                 FormatForComparisonFailureMessage(expected, actual),
                                 FormatForComparisonFailureMessage(actual, expected),
                                 false);
            }

#ifdef _MSC_VER
# pragma warning(pop)          // Restores the warning state.
#endif
            return EqFailure(expected_expression,
                             actual_expression,
                             FormatForComparisonFailureMessage(expected, actual),
                             FormatForComparisonFailureMessage(actual, expected),
                             false);
        }

        // With this overloaded version, we allow anonymous enums to be used
        // in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous enums
        // can be implicitly cast to BiggestInt.
        GTEST_API_ AssertionResult CmpHelperEQ(const char *expected_expression,
                                               const char *actual_expression,
                                               BiggestInt expected,
                                               BiggestInt actual);

        // The helper class for {ASSERT|EXPECT}_EQ.  The template argument
        // lhs_is_null_literal is true iff the first argument to ASSERT_EQ()
        // is a null pointer literal.  The following default implementation is
        // for lhs_is_null_literal being false.
        template <bool lhs_is_null_literal>
        class EqHelper
        {
        public:
            // This templatized version is for the general case.
            template <typename T1, typename T2>
            static AssertionResult Compare(const char *expected_expression,
                                           const char *actual_expression,
                                           const T1 &expected,
                                           const T2 &actual)
            {
                return CmpHelperEQ(expected_expression, actual_expression, expected,
                                   actual);
            }

            // With this overloaded version, we allow anonymous enums to be used
            // in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous
            // enums can be implicitly cast to BiggestInt.
            //
            // Even though its body looks the same as the above version, we
            // cannot merge the two, as it will make anonymous enums unhappy.
            static AssertionResult Compare(const char *expected_expression,
                                           const char *actual_expression,
                                           BiggestInt expected,
                                           BiggestInt actual)
            {
                return CmpHelperEQ(expected_expression, actual_expression, expected,
                                   actual);
            }
        };

        // This specialization is used when the first argument to ASSERT_EQ()
        // is a null pointer literal, like NULL, false, or 0.
        template <>
        class EqHelper<true>
        {
        public:
            // We define two overloaded versions of Compare().  The first
            // version will be picked when the second argument to ASSERT_EQ() is
            // NOT a pointer, e.g. ASSERT_EQ(0, AnIntFunction()) or
            // EXPECT_EQ(false, a_bool).
            template <typename T1, typename T2>
            static AssertionResult Compare(
                const char *expected_expression,
                const char *actual_expression,
                const T1 &expected,
                const T2 &actual,
                // The following line prevents this overload from being considered if T2
                // is not a pointer type.  We need this because ASSERT_EQ(NULL, my_ptr)
                // expands to Compare("", "", NULL, my_ptr), which requires a conversion
                // to match the Secret* in the other overload, which would otherwise make
                // this template match better.
                typename EnableIf < !is_pointer<T2>::value >::type* = 0)
            {
                return CmpHelperEQ(expected_expression, actual_expression, expected,
                                   actual);
            }

            // This version will be picked when the second argument to ASSERT_EQ() is a
            // pointer, e.g. ASSERT_EQ(NULL, a_pointer).
            template <typename T>
            static AssertionResult Compare(
                const char *expected_expression,
                const char *actual_expression,
                // We used to have a second template parameter instead of Secret*.  That
                // template parameter would deduce to 'long', making this a better match
                // than the first overload even without the first overload's EnableIf.
                // Unfortunately, gcc with -Wconversion-null warns when "passing NULL to
                // non-pointer argument" (even a deduced integral argument), so the old
                // implementation caused warnings in user code.
                Secret * /* expected (NULL) */,
                T *actual)
            {
                // We already know that 'expected' is a null pointer.
                return CmpHelperEQ(expected_expression, actual_expression,
                                   static_cast<T *>(NULL), actual);
            }
        };

        // A macro for implementing the helper functions needed to implement
        // ASSERT_?? and EXPECT_??.  It is here just to avoid copy-and-paste
        // of similar code.
        //
        // For each templatized helper function, we also define an overloaded
        // version for BiggestInt in order to reduce code bloat and allow
        // anonymous enums to be used with {ASSERT|EXPECT}_?? when compiled
        // with gcc 4.
        //
        // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
#define GTEST_IMPL_CMP_HELPER_(op_name, op)\
    template <typename T1, typename T2>\
    AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
                                       const T1& val1, const T2& val2) {\
        if (val1 op val2) {\
            Message msg;\
            msg << "Expected: (" << expr1 << ") " #op " (" << expr2\
                << "), actual: " << FormatForComparisonFailureMessage(val1, val2)\
                << " vs " << FormatForComparisonFailureMessage(val2, val1);\
            return AssertionSuccess(msg);\
        } else {\
            return AssertionFailure() \
                   << "Expected: (" << expr1 << ") " #op " (" << expr2\
                   << "), actual: " << FormatForComparisonFailureMessage(val1, val2)\
                   << " vs " << FormatForComparisonFailureMessage(val2, val1);\
        }\
    }\
    GTEST_API_ AssertionResult CmpHelper##op_name(\
            const char* expr1, const char* expr2, BiggestInt val1, BiggestInt val2)

        // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.

        // Implements the helper function for {ASSERT|EXPECT}_NE
        GTEST_IMPL_CMP_HELPER_(NE, !=);
        // Implements the helper function for {ASSERT|EXPECT}_LE
        GTEST_IMPL_CMP_HELPER_(LE, <=);
        // Implements the helper function for {ASSERT|EXPECT}_LT
        GTEST_IMPL_CMP_HELPER_(LT, <);
        // Implements the helper function for {ASSERT|EXPECT}_GE
        GTEST_IMPL_CMP_HELPER_(GE, >=);
        // Implements the helper function for {ASSERT|EXPECT}_GT
        GTEST_IMPL_CMP_HELPER_(GT, >);

#undef GTEST_IMPL_CMP_HELPER_

        // The helper function for {ASSERT|EXPECT}_STREQ.
        //
        // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
        GTEST_API_ AssertionResult CmpHelperSTREQ(const char *expected_expression,
                const char *actual_expression,
                const char *expected,
                const char *actual);

        // The helper function for {ASSERT|EXPECT}_STRCASEEQ.
        //
        // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
        GTEST_API_ AssertionResult CmpHelperSTRCASEEQ(const char *expected_expression,
                const char *actual_expression,
                const char *expected,
                const char *actual);

        // The helper function for {ASSERT|EXPECT}_STRNE.
        //
        // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
        GTEST_API_ AssertionResult CmpHelperSTRNE(const char *s1_expression,
                const char *s2_expression,
                const char *s1,
                const char *s2);

        // The helper function for {ASSERT|EXPECT}_STRCASENE.
        //
        // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
        GTEST_API_ AssertionResult CmpHelperSTRCASENE(const char *s1_expression,
                const char *s2_expression,
                const char *s1,
                const char *s2);


        // Helper function for *_STREQ on wide strings.
        //
        // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
        GTEST_API_ AssertionResult CmpHelperSTREQ(const char *expected_expression,
                const char *actual_expression,
                const wchar_t *expected,
                const wchar_t *actual);

        // Helper function for *_STRNE on wide strings.
        //
        // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
        GTEST_API_ AssertionResult CmpHelperSTRNE(const char *s1_expression,
                const char *s2_expression,
                const wchar_t *s1,
                const wchar_t *s2);

    }  // namespace internal

    // IsSubstring() and IsNotSubstring() are intended to be used as the
    // first argument to {EXPECT,ASSERT}_PRED_FORMAT2(), not by
    // themselves.  They check whether needle is a substring of haystack
    // (NULL is considered a substring of itself only), and return an
    // appropriate error message when they fail.
    //
    // The {needle,haystack}_expr arguments are the stringified
    // expressions that generated the two real arguments.
    GTEST_API_ AssertionResult IsSubstring(
        const char *needle_expr, const char *haystack_expr,
        const char *needle, const char *haystack);
    GTEST_API_ AssertionResult IsSubstring(
        const char *needle_expr, const char *haystack_expr,
        const wchar_t *needle, const wchar_t *haystack);
    GTEST_API_ AssertionResult IsNotSubstring(
        const char *needle_expr, const char *haystack_expr,
        const char *needle, const char *haystack);
    GTEST_API_ AssertionResult IsNotSubstring(
        const char *needle_expr, const char *haystack_expr,
        const wchar_t *needle, const wchar_t *haystack);
    GTEST_API_ AssertionResult IsSubstring(
        const char *needle_expr, const char *haystack_expr,
        const ::std::string &needle, const ::std::string &haystack);
    GTEST_API_ AssertionResult IsNotSubstring(
        const char *needle_expr, const char *haystack_expr,
        const ::std::string &needle, const ::std::string &haystack);

#if GTEST_HAS_STD_WSTRING
    GTEST_API_ AssertionResult IsSubstring(
        const char *needle_expr, const char *haystack_expr,
        const ::std::wstring &needle, const ::std::wstring &haystack);
    GTEST_API_ AssertionResult IsNotSubstring(
        const char *needle_expr, const char *haystack_expr,
        const ::std::wstring &needle, const ::std::wstring &haystack);
#endif  // GTEST_HAS_STD_WSTRING

    namespace internal
    {

        // Helper template function for comparing floating-points.
        //
        // Template parameter:
        //
        //   RawType: the raw floating-point type (either float or double)
        //
        // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
        template <typename RawType>
        AssertionResult CmpHelperFloatingPointEQ(const char *expected_expression,
                const char *actual_expression,
                RawType expected,
                RawType actual)
        {
            const FloatingPoint<RawType> lhs(expected), rhs(actual);

            if (lhs.AlmostEquals(rhs))
            {
                return AssertionSuccess();
            }

            ::std::stringstream expected_ss;
            expected_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
                        << expected;
            ::std::stringstream actual_ss;
            actual_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
                      << actual;

            if (lhs.AlmostEquals(rhs))
            {
                return EqSuccess(expected_expression,
                                 actual_expression,
                                 StringStreamToString(&expected_ss),
                                 StringStreamToString(&actual_ss),
                                 false);
            }

            return EqFailure(expected_expression,
                             actual_expression,
                             StringStreamToString(&expected_ss),
                             StringStreamToString(&actual_ss),
                             false);
        }

        // Helper function for implementing ASSERT_NEAR.
        //
        // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
        GTEST_API_ AssertionResult DoubleNearPredFormat(const char *expr1,
                const char *expr2,
                const char *abs_error_expr,
                double val1,
                double val2,
                double abs_error);

        // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
        // A class that enables one to stream messages to assertion macros
        class GTEST_API_ AssertHelper
        {
        public:
            // Constructor.
            AssertHelper(TestPartResult::Type type,
                         const char *file,
                         int line,
                         const char *message);
            ~AssertHelper();

            // Message assignment is a semantic trick to enable assertion
            // streaming; see the GTEST_MESSAGE_ macro below.
            void operator=(const Message &message) const;

        private:
            // We put our data in a struct so that the size of the AssertHelper class can
            // be as small as possible.  This is important because gcc is incapable of
            // re-using stack space even for temporary variables, so every EXPECT_EQ
            // reserves stack space for another AssertHelper.
            struct AssertHelperData
            {
                AssertHelperData(TestPartResult::Type t,
                                 const char *srcfile,
                                 int line_num,
                                 const char *msg)
                    : type(t), file(srcfile), line(line_num), message(msg) { }

                TestPartResult::Type const type;
                const char        *const file;
                int                const line;
                String             const message;

            private:
                GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelperData);
            };

            AssertHelperData *const data_;

            GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelper);
        };

    }  // namespace internal

#if GTEST_HAS_PARAM_TEST
    // The pure interface class that all value-parameterized tests inherit from.
    // A value-parameterized class must inherit from both ::testing::Test and
    // ::testing::WithParamInterface. In most cases that just means inheriting
    // from ::testing::TestWithParam, but more complicated test hierarchies
    // may need to inherit from Test and WithParamInterface at different levels.
    //
    // This interface has support for accessing the test parameter value via
    // the GetParam() method.
    //
    // Use it with one of the parameter generator defining functions, like Range(),
    // Values(), ValuesIn(), Bool(), and Combine().
    //
    // class FooTest : public ::testing::TestWithParam<int> {
    //  protected:
    //   FooTest() {
    //     // Can use GetParam() here.
    //   }
    //   virtual ~FooTest() {
    //     // Can use GetParam() here.
    //   }
    //   virtual void SetUp() {
    //     // Can use GetParam() here.
    //   }
    //   virtual void TearDown {
    //     // Can use GetParam() here.
    //   }
    // };
    // TEST_P(FooTest, DoesBar) {
    //   // Can use GetParam() method here.
    //   Foo foo;
    //   ASSERT_TRUE(foo.DoesBar(GetParam()));
    // }
    // INSTANTIATE_TEST_CASE_P(OneToTenRange, FooTest, ::testing::Range(1, 10));

    template <typename T>
    class WithParamInterface
    {
    public:
        typedef T ParamType;
        virtual ~WithParamInterface() {}

        // The current parameter value. Is also available in the test fixture's
        // constructor. This member function is non-static, even though it only
        // references static data, to reduce the opportunity for incorrect uses
        // like writing 'WithParamInterface<bool>::GetParam()' for a test that
        // uses a fixture whose parameter type is int.
        const ParamType &GetParam() const
        {
            return *parameter_;
        }

    private:
        // Sets parameter value. The caller is responsible for making sure the value
        // remains alive and unchanged throughout the current test.
        static void SetParam(const ParamType *parameter)
        {
            parameter_ = parameter;
        }

        // Static value used for accessing parameter during a test lifetime.
        static const ParamType *parameter_;

        // TestClass must be a subclass of WithParamInterface<T> and Test.
        template <class TestClass> friend class internal::ParameterizedTestFactory;
    };

    template <typename T>
    const T *WithParamInterface<T>::parameter_ = NULL;

    // Most value-parameterized classes can ignore the existence of
    // WithParamInterface, and can just inherit from ::testing::TestWithParam.

    template <typename T>
    class TestWithParam : public Test, public WithParamInterface<T>
    {
    public:
        typedef T ParamType;

        template <typename T1>
        void PrintParam(const T1 &) const {}

        void PrintParam(const char &param) const
        {
            const char *banner = "[=================================================]";
            ::std::cout << banner <<::std::endl << param <<::std::endl << banner <<::std::endl;
        }

        void PrintParam(const unsigned char &param) const
        {
            const char *banner = "[=================================================]";
            ::std::cout << banner <<::std::endl << param <<::std::endl << banner <<::std::endl;
        }

        void PrintParam(const short &param) const
        {
            const char *banner = "[=================================================]";
            ::std::cout << banner <<::std::endl << param <<::std::endl << banner <<::std::endl;
        }

        void PrintParam(const unsigned short &param) const
        {
            const char *banner = "[=================================================]";
            ::std::cout << banner <<::std::endl << param <<::std::endl << banner <<::std::endl;
        }

        void PrintParam(const int &param) const
        {
            const char *banner = "[=================================================]";
            ::std::cout << banner <<::std::endl << param <<::std::endl << banner <<::std::endl;
        }

        void PrintParam(const unsigned int &param) const
        {
            const char *banner = "[=================================================]";
            ::std::cout << banner <<::std::endl << param <<::std::endl << banner <<::std::endl;
        }

        void PrintParam(const long &param) const
        {
            const char *banner = "[=================================================]";
            ::std::cout << banner <<::std::endl << param <<::std::endl << banner <<::std::endl;
        }

        void PrintParam(const unsigned long &param) const
        {
            const char *banner = "[=================================================]";
            ::std::cout << banner <<::std::endl << param <<::std::endl << banner <<::std::endl;
        }

        void PrintParam(const long long &param) const
        {
            const char *banner = "[=================================================]";
            ::std::cout << banner <<::std::endl << param <<::std::endl << banner <<::std::endl;
        }

        void PrintParam(const unsigned long long &param) const
        {
            const char *banner = "[=================================================]";
            ::std::cout << banner <<::std::endl << param <<::std::endl << banner <<::std::endl;
        }

        void PrintParam(const float &param) const
        {
            const char *banner = "[=================================================]";
            ::std::cout << banner <<::std::endl << param <<::std::endl << banner <<::std::endl;
        }

        void PrintParam(const double &param) const
        {
            const char *banner = "[=================================================]";
            ::std::cout << banner <<::std::endl << param <<::std::endl << banner <<::std::endl;
        }

        void PrintParam(const long double &param) const
        {
            const char *banner = "[=================================================]";
            ::std::cout << banner <<::std::endl << param <<::std::endl << banner <<::std::endl;
        }

        void PrintParam(const ::std::string &param) const
        {
            const char *banner = "[=================================================]";
            ::std::cout << banner <<::std::endl << param <<::std::endl << banner <<::std::endl;
        }

        // The current parameter value. Is also available in the test fixture's
        // constructor.
        const ParamType &GetParam() const
        {
            if (string(GTEST_FLAG(db_print_param).c_str()).compare("yes") == 0)
            {
                PrintParam(WithParamInterface<T>::GetParam());
                ::std::cout.flush();
            }

            return WithParamInterface<T>::GetParam();
        }
    };

#endif  // GTEST_HAS_PARAM_TEST

    // Macros for indicating success/failure in test code.

    // ADD_FAILURE unconditionally adds a failure to the current test.
    // SUCCEED generates a success - it doesn't automatically make the
    // current test successful, as a test is only successful when it has
    // no failure.
    //
    // EXPECT_* verifies that a certain condition is satisfied.  If not,
    // it behaves like ADD_FAILURE.  In particular:
    //
    //   EXPECT_TRUE  verifies that a Boolean condition is true.
    //   EXPECT_FALSE verifies that a Boolean condition is false.
    //
    // FAIL and ASSERT_* are similar to ADD_FAILURE and EXPECT_*, except
    // that they will also abort the current function on failure.  People
    // usually want the fail-fast behavior of FAIL and ASSERT_*, but those
    // writing data-driven tests often find themselves using ADD_FAILURE
    // and EXPECT_* more.
    //
    // Examples:
    //
    //   EXPECT_TRUE(server.StatusIsOK());
    //   ASSERT_FALSE(server.HasPendingRequest(port))
    //       << "There are still pending requests " << "on port " << port;

    // Generates a nonfatal failure with a generic message.
#define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed")

    // Generates a nonfatal failure at the given source file location with
    // a generic message.
#define ADD_FAILURE_AT(file, line) \
    GTEST_MESSAGE_AT_(file, line, "Failed", \
                      ::testing::TestPartResult::kNonFatalFailure)

    // Generates a fatal failure with a generic message.
#define GTEST_FAIL() GTEST_FATAL_FAILURE_("Failed")

    // Define this macro to 1 to omit the definition of FAIL(), which is a
    // generic name and clashes with some other libraries.
#if !GTEST_DONT_DEFINE_FAIL
# define FAIL() GTEST_FAIL()
#endif

    // Generates a success with a generic message.
#define GTEST_SUCCEED() GTEST_SUCCESS_("Succeeded")

    // Define this macro to 1 to omit the definition of SUCCEED(), which
    // is a generic name and clashes with some other libraries.
#if !GTEST_DONT_DEFINE_SUCCEED
# define SUCCEED() GTEST_SUCCEED()
#endif

    // Macros for testing exceptions.
    //
    //    * {ASSERT|EXPECT}_THROW(statement, expected_exception):
    //         Tests that the statement throws the expected exception.
    //    * {ASSERT|EXPECT}_NO_THROW(statement):
    //         Tests that the statement doesn't throw any exception.
    //    * {ASSERT|EXPECT}_ANY_THROW(statement):
    //         Tests that the statement throws an exception.

#define EXPECT_THROW(statement, expected_exception) \
    GTEST_TEST_THROW_(statement, expected_exception, GTEST_NONFATAL_FAILURE_)
#define EXPECT_NO_THROW(statement) \
    GTEST_TEST_NO_THROW_(statement, GTEST_NONFATAL_FAILURE_)
#define EXPECT_ANY_THROW(statement) \
    GTEST_TEST_ANY_THROW_(statement, GTEST_NONFATAL_FAILURE_)
#define ASSERT_THROW(statement, expected_exception) \
    GTEST_TEST_THROW_(statement, expected_exception, GTEST_FATAL_FAILURE_)
#define ASSERT_NO_THROW(statement) \
    GTEST_TEST_NO_THROW_(statement, GTEST_FATAL_FAILURE_)
#define ASSERT_ANY_THROW(statement) \
    GTEST_TEST_ANY_THROW_(statement, GTEST_FATAL_FAILURE_)

    // Boolean assertions. Condition can be either a Boolean expression or an
    // AssertionResult. For more information on how to use AssertionResult with
    // these macros see comments on that class.
#define EXPECT_TRUE(condition) \
    GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
                        GTEST_NONFATAL_FAILURE_)
#define EXPECT_FALSE(condition) \
    GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
                        GTEST_NONFATAL_FAILURE_)

#ifdef ASSERT_TRUE
#undef ASSERT_TRUE
#endif

#define ASSERT_TRUE(condition) \
    GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
                        GTEST_FATAL_FAILURE_)
#define ASSERT_FALSE(condition) \
    GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
                        GTEST_FATAL_FAILURE_)

    // Includes the auto-generated header that implements a family of
    // generic predicate assertion macros.
#include "gtest/gtest_pred_impl.h"

    // Macros for testing equalities and inequalities.
    //
    //    * {ASSERT|EXPECT}_EQ(expected, actual): Tests that expected == actual
    //    * {ASSERT|EXPECT}_NE(v1, v2):           Tests that v1 != v2
    //    * {ASSERT|EXPECT}_LT(v1, v2):           Tests that v1 < v2
    //    * {ASSERT|EXPECT}_LE(v1, v2):           Tests that v1 <= v2
    //    * {ASSERT|EXPECT}_GT(v1, v2):           Tests that v1 > v2
    //    * {ASSERT|EXPECT}_GE(v1, v2):           Tests that v1 >= v2
    //
    // When they are not, Google Test prints both the tested expressions and
    // their actual values.  The values must be compatible built-in types,
    // or you will get a compiler error.  By "compatible" we mean that the
    // values can be compared by the respective operator.
    //
    // Note:
    //
    //   1. It is possible to make a user-defined type work with
    //   {ASSERT|EXPECT}_??(), but that requires overloading the
    //   comparison operators and is thus discouraged by the Google C++
    //   Usage Guide.  Therefore, you are advised to use the
    //   {ASSERT|EXPECT}_TRUE() macro to assert that two objects are
    //   equal.
    //
    //   2. The {ASSERT|EXPECT}_??() macros do pointer comparisons on
    //   pointers (in particular, C strings).  Therefore, if you use it
    //   with two C strings, you are testing how their locations in memory
    //   are related, not how their content is related.  To compare two C
    //   strings by content, use {ASSERT|EXPECT}_STR*().
    //
    //   3. {ASSERT|EXPECT}_EQ(expected, actual) is preferred to
    //   {ASSERT|EXPECT}_TRUE(expected == actual), as the former tells you
    //   what the actual value is when it fails, and similarly for the
    //   other comparisons.
    //
    //   4. Do not depend on the order in which {ASSERT|EXPECT}_??()
    //   evaluate their arguments, which is undefined.
    //
    //   5. These macros evaluate their arguments exactly once.
    //
    // Examples:
    //
    //   EXPECT_NE(5, Foo());
    //   EXPECT_EQ(NULL, a_pointer);
    //   ASSERT_LT(i, array_size);
    //   ASSERT_GT(records.size(), 0) << "There is no record left.";

#define EXPECT_EQ(expected, actual) \
    EXPECT_PRED_FORMAT2(::testing::internal:: \
                        EqHelper<GTEST_IS_NULL_LITERAL_(expected)>::Compare, \
                        expected, actual)
#define EXPECT_NE(expected, actual) \
    EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, expected, actual)
#define EXPECT_LE(val1, val2) \
    EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
#define EXPECT_LT(val1, val2) \
    EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
#define EXPECT_GE(val1, val2) \
    EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
#define EXPECT_GT(val1, val2) \
    EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)

#define GTEST_ASSERT_EQ(expected, actual) \
    ASSERT_PRED_FORMAT2(::testing::internal:: \
                        EqHelper<GTEST_IS_NULL_LITERAL_(expected)>::Compare, \
                        expected, actual)
#define GTEST_ASSERT_NE(val1, val2) \
    ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
#define GTEST_ASSERT_LE(val1, val2) \
    ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
#define GTEST_ASSERT_LT(val1, val2) \
    ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
#define GTEST_ASSERT_GE(val1, val2) \
    ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
#define GTEST_ASSERT_GT(val1, val2) \
    ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)

    // Define macro GTEST_DONT_DEFINE_ASSERT_XY to 1 to omit the definition of
    // ASSERT_XY(), which clashes with some users' own code.

#if !GTEST_DONT_DEFINE_ASSERT_EQ
# define ASSERT_EQ(val1, val2) GTEST_ASSERT_EQ(val1, val2)
#endif

#if !GTEST_DONT_DEFINE_ASSERT_NE
# define ASSERT_NE(val1, val2) GTEST_ASSERT_NE(val1, val2)
#endif

#if !GTEST_DONT_DEFINE_ASSERT_LE
# define ASSERT_LE(val1, val2) GTEST_ASSERT_LE(val1, val2)
#endif

#if !GTEST_DONT_DEFINE_ASSERT_LT
# define ASSERT_LT(val1, val2) GTEST_ASSERT_LT(val1, val2)
#endif

#if !GTEST_DONT_DEFINE_ASSERT_GE
# define ASSERT_GE(val1, val2) GTEST_ASSERT_GE(val1, val2)
#endif

#if !GTEST_DONT_DEFINE_ASSERT_GT
# define ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2)
#endif

    // C String Comparisons.  All tests treat NULL and any non-NULL string
    // as different.  Two NULLs are equal.
    //
    //    * {ASSERT|EXPECT}_STREQ(s1, s2):     Tests that s1 == s2
    //    * {ASSERT|EXPECT}_STRNE(s1, s2):     Tests that s1 != s2
    //    * {ASSERT|EXPECT}_STRCASEEQ(s1, s2): Tests that s1 == s2, ignoring case
    //    * {ASSERT|EXPECT}_STRCASENE(s1, s2): Tests that s1 != s2, ignoring case
    //
    // For wide or narrow string objects, you can use the
    // {ASSERT|EXPECT}_??() macros.
    //
    // Don't depend on the order in which the arguments are evaluated,
    // which is undefined.
    //
    // These macros evaluate their arguments exactly once.

#define EXPECT_STREQ(expected, actual) \
    EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, expected, actual)
#define EXPECT_STRNE(s1, s2) \
    EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
#define EXPECT_STRCASEEQ(expected, actual) \
    EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, expected, actual)
#define EXPECT_STRCASENE(s1, s2)\
    EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)

#define ASSERT_STREQ(expected, actual) \
    ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, expected, actual)
#define ASSERT_STRNE(s1, s2) \
    ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
#define ASSERT_STRCASEEQ(expected, actual) \
    ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, expected, actual)
#define ASSERT_STRCASENE(s1, s2)\
    ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)

    // Macros for comparing floating-point numbers.
    //
    //    * {ASSERT|EXPECT}_FLOAT_EQ(expected, actual):
    //         Tests that two float values are almost equal.
    //    * {ASSERT|EXPECT}_DOUBLE_EQ(expected, actual):
    //         Tests that two double values are almost equal.
    //    * {ASSERT|EXPECT}_NEAR(v1, v2, abs_error):
    //         Tests that v1 and v2 are within the given distance to each other.
    //
    // Google Test uses ULP-based comparison to automatically pick a default
    // error bound that is appropriate for the operands.  See the
    // FloatingPoint template class in gtest-internal.h if you are
    // interested in the implementation details.

#define EXPECT_FLOAT_EQ(expected, actual)\
    EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
                        expected, actual)

#define EXPECT_DOUBLE_EQ(expected, actual)\
    EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
                        expected, actual)

#define ASSERT_FLOAT_EQ(expected, actual)\
    ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
                        expected, actual)

#define ASSERT_DOUBLE_EQ(expected, actual)\
    ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
                        expected, actual)

#define EXPECT_NEAR(val1, val2, abs_error)\
    EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
                        val1, val2, abs_error)

#define ASSERT_NEAR(val1, val2, abs_error)\
    ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
                        val1, val2, abs_error)

    // These predicate format functions work on floating-point values, and
    // can be used in {ASSERT|EXPECT}_PRED_FORMAT2*(), e.g.
    //
    //   EXPECT_PRED_FORMAT2(testing::DoubleLE, Foo(), 5.0);

    // Asserts that val1 is less than, or almost equal to, val2.  Fails
    // otherwise.  In particular, it fails if either val1 or val2 is NaN.
    GTEST_API_ AssertionResult FloatLE(const char *expr1, const char *expr2,
                                       float val1, float val2);
    GTEST_API_ AssertionResult DoubleLE(const char *expr1, const char *expr2,
                                        double val1, double val2);


#if GTEST_OS_WINDOWS

    // Macros that test for HRESULT failure and success, these are only useful
    // on Windows, and rely on Windows SDK macros and APIs to compile.
    //
    //    * {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}(expr)
    //
    // When expr unexpectedly fails or succeeds, Google Test prints the
    // expected result and the actual result with both a human-readable
    // string representation of the error, if available, as well as the
    // hex result code.
# define EXPECT_HRESULT_SUCCEEDED(expr) \
    EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))

# define ASSERT_HRESULT_SUCCEEDED(expr) \
    ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))

# define EXPECT_HRESULT_FAILED(expr) \
    EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))

# define ASSERT_HRESULT_FAILED(expr) \
    ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))

#endif  // GTEST_OS_WINDOWS

    // Macros that execute statement and check that it doesn't generate new fatal
    // failures in the current thread.
    //
    //   * {ASSERT|EXPECT}_NO_FATAL_FAILURE(statement);
    //
    // Examples:
    //
    //   EXPECT_NO_FATAL_FAILURE(Process());
    //   ASSERT_NO_FATAL_FAILURE(Process()) << "Process() failed";
    //
#define ASSERT_NO_FATAL_FAILURE(statement) \
    GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_FATAL_FAILURE_)
#define EXPECT_NO_FATAL_FAILURE(statement) \
    GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_NONFATAL_FAILURE_)

    // Causes a trace (including the source file path, the current line
    // number, and the given message) to be included in every test failure
    // message generated by code in the current scope.  The effect is
    // undone when the control leaves the current scope.
    //
    // The message argument can be anything streamable to std::ostream.
    //
    // In the implementation, we include the current line number as part
    // of the dummy variable name, thus allowing multiple SCOPED_TRACE()s
    // to appear in the same block - as long as they are on different
    // lines.
#define SCOPED_TRACE(message) \
    ::testing::internal::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)(\
            __FILE__, __LINE__, ::testing::Message() << (message))

    // Compile-time assertion for type equality.
    // StaticAssertTypeEq<type1, type2>() compiles iff type1 and type2 are
    // the same type.  The value it returns is not interesting.
    //
    // Instead of making StaticAssertTypeEq a class template, we make it a
    // function template that invokes a helper class template.  This
    // prevents a user from misusing StaticAssertTypeEq<T1, T2> by
    // defining objects of that type.
    //
    // CAVEAT:
    //
    // When used inside a method of a class template,
    // StaticAssertTypeEq<T1, T2>() is effective ONLY IF the method is
    // instantiated.  For example, given:
    //
    //   template <typename T> class Foo {
    //    public:
    //     void Bar() { testing::StaticAssertTypeEq<int, T>(); }
    //   };
    //
    // the code:
    //
    //   void Test1() { Foo<bool> foo; }
    //
    // will NOT generate a compiler error, as Foo<bool>::Bar() is never
    // actually instantiated.  Instead, you need:
    //
    //   void Test2() { Foo<bool> foo; foo.Bar(); }
    //
    // to cause a compiler error.
    template <typename T1, typename T2>
    bool StaticAssertTypeEq()
    {
        (void)internal::StaticAssertTypeEqHelper<T1, T2>();
        return true;
    }

    // Defines a test.
    //
    // The first parameter is the name of the test case, and the second
    // parameter is the name of the test within the test case.
    //
    // The convention is to end the test case name with "Test".  For
    // example, a test case for the Foo class can be named FooTest.
    //
    // The user should put his test code between braces after using this
    // macro.  Example:
    //
    //   TEST(FooTest, InitializesCorrectly) {
    //     Foo foo;
    //     EXPECT_TRUE(foo.StatusIsOK());
    //   }

    // Note that we call GetTestTypeId() instead of GetTypeId<
    // ::testing::Test>() here to get the type ID of testing::Test.  This
    // is to work around a suspected linker bug when using Google Test as
    // a framework on Mac OS X.  The bug causes GetTypeId<
    // ::testing::Test>() to return different values depending on whether
    // the call is from the Google Test framework itself or from user test
    // code.  GetTestTypeId() is guaranteed to always return the same
    // value, as it always calls GetTypeId<>() from the Google Test
    // framework.
#define GTEST_TEST(test_case_name, test_name)\
    GTEST_TEST_(test_case_name, test_name, \
                ::testing::Test, ::testing::internal::GetTestTypeId())

    // Define this macro to 1 to omit the definition of TEST(), which
    // is a generic name and clashes with some other libraries.
#if !GTEST_DONT_DEFINE_TEST
# define TEST(test_case_name, test_name) GTEST_TEST(test_case_name, test_name)
#endif

    // Defines a test that uses a test fixture.
    //
    // The first parameter is the name of the test fixture class, which
    // also doubles as the test case name.  The second parameter is the
    // name of the test within the test case.
    //
    // A test fixture class must be declared earlier.  The user should put
    // his test code between braces after using this macro.  Example:
    //
    //   class FooTest : public testing::Test {
    //    protected:
    //     virtual void SetUp() { b_.AddElement(3); }
    //
    //     Foo a_;
    //     Foo b_;
    //   };
    //
    //   TEST_F(FooTest, InitializesCorrectly) {
    //     EXPECT_TRUE(a_.StatusIsOK());
    //   }
    //
    //   TEST_F(FooTest, ReturnsElementCountCorrectly) {
    //     EXPECT_EQ(0, a_.size());
    //     EXPECT_EQ(1, b_.size());
    //   }

#define TEST_F(test_fixture, test_name)\
    GTEST_TEST_(test_fixture, test_name, test_fixture, \
                ::testing::internal::GetTypeId<test_fixture>())

    // Use this macro in main() to run all tests.  It returns 0 if all
    // tests are successful, or 1 otherwise.
    //
    // RUN_ALL_TESTS() should be invoked after the command line has been
    // parsed by InitGoogleTest().

#define RUN_ALL_TESTS(args...)\
    (::testing::UnitTest::GetInstance()->Run(args))

#define RUN_ALL_TESTS_IN_PROC()\
    (::testing::UnitTest::GetInstance()->Run(1))

}  // namespace testing

class Btest
{
public:
    Btest() {};

    ~Btest() {};

    bool Run(void *instance , void *data, const char *filter)
    {
        int argc = 2;
        char *argv[3];
        char gtest_flag[256];
        char name[256] = "init_more_than_one";
        sprintf(gtest_flag, "--gtest_filter=%s", filter);
        argv[0] = name;
        argv[1] = gtest_flag;
        argv[2] = NULL;
        testing::InitGoogleTest(&argc, argv);

        if (RUN_ALL_TESTS(instance, data) == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    // reset gtest variables so that it can initialize more than once
    void ResetBtest()
    {
        testing::ResetGoogleTest();
    }

    bool Run(void *instance , void *data, const char *filter, const char *other_parameter)
    {
        int argc = 2;
        char parameter[1024];
        snprintf(parameter, 1024, "%s", other_parameter);
        char *pparameter = parameter;
        char *pparameter_end = NULL;
        char *argv[100];
        char cmd[1024];
        char gtest_flag[256];
        char name[256] = "init_more_than_one";
        sprintf(gtest_flag, "--gtest_filter=%s", filter);
        argv[0] = name;
        argv[1] = gtest_flag;

        while (pparameter != NULL && strlen(pparameter) > 0)
        {
            pparameter_end = strstr(pparameter, " ");

            if (pparameter_end != NULL)
            {
                *pparameter_end = 0;
            }

            argv[argc] = pparameter;
            // if --gtest_ouput=xml format, backup original xml
            char *pgtest_output = NULL;
            pgtest_output = strstr(pparameter, "--gtest_output=xml:");

            if (pgtest_output != NULL)
            {
                snprintf(cmd, 1024, "cat %s >>%s.total", &pgtest_output[strlen("--gtest_output=xml:")], &pgtest_output[strlen("--gtest_output=xml:")]);
                system(cmd);
            }

            argc++;

            if (pparameter_end != NULL)
            {
                pparameter = pparameter_end + 1;
            }
            else
            {
                pparameter = NULL;
            }
        }

        argv[argc] = NULL;
        testing::InitGoogleTest(&argc, argv);

        if (RUN_ALL_TESTS(instance, data) == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

};

#endif  // GTEST_INCLUDE_GTEST_GTEST_H_
